#38  WAV/VOC/SND/IFF/AU/RAW  8bit laden

Das Verzeichnis von FFT4WAVE wird nach SOUND-Dateien durchsucht.
Also suche nach WAV/VOC/SND/IFF/AU/RAW/SAM/MAT Dateien (Maximum 4096).
Aus diesen Dateien müssen Sie eine Datei mit Hilfe des Scrollmenüs
auswählen. Diese wird dann am Bildschirm angezeigt und Sie können sich
mit Hilfe der Maus einen beliebigen Startpunkt innerhalb der Datei wählen.
Folgende Tasten stehen zusätzlich zur Verfügung:

Esc:                    Funktion abbrechen.   
Tab, rechte Maustaste:  Umschalten zwischen signed/unsigned Mode. 
      linke Maustaste:  Datei ab Startpunkt laden.

FFT4WAVE kennt nur den Header von WAV-Dateien. Aus dem WAV-Header wird die
Information: Samplerate, 8bit_unsigned / 16bit_signed, Stereo/Mono gelesen.
Stereo WAV-Dateien werden als  Real & Imag. Daten  interpretiert,
und MONO Dateien (default) werden als reelle Daten interpretiert.
Es werden nur soviele Abtastwerte gelesen wie in der INI-Datei vereinbart!
VOC/SND/IFF/AU/RAW/SAM/MAT Dateien werden als mono 8bit unsigned interpretiert,
mit der in der INI-Datei vereinbarten Samplerate (11000).

#39  WAV/VOC/SND/IFF/AU/RAW 16bit laden

Das Verzeichnis von FFT4WAVE wird nach SOUND-Dateien durchsucht.
Also suche nach WAV/VOC/SND/IFF/AU/RAW/SAM/MAT Dateien (Maximum 4096).
Aus diesen Dateien müssen Sie eine Datei mit Hilfe des Scrollmenüs
auswählen. Diese wird dann am Bildschirm angezeigt und Sie können sich
mit Hilfe der Maus einen beliebigen Startpunkt innerhalb der Datei wählen.
Folgende Tasten stehen zusätzlich zur Verfügung:

Esc:                    Funktion abbrechen.   
Tab, rechte Maustaste:  Umschalten zwischen signed/unsigned Mode. 
      linke Maustaste:  Datei ab Startpunkt laden.

FFT4WAVE kennt nur den Header von WAV-Dateien. Aus dem WAV-Header wird die
Information: Samplerate, 8bit_unsigned / 16bit_signed, Stereo/Mono gelesen.
Stereo WAV-Dateien werden als  Real & Imag. Daten  interpretiert,
und MONO Dateien (default) werden als reelle Daten interpretiert.
Es werden nur soviele Abtastwerte gelesen wie in der INI-Datei vereinbart!
VOC/SND/IFF/AU/RAW/SAM/MAT Dateien werden als mono 16bit signed interpretiert,
mit der in der INI-Datei vereinbarten Samplerate (11000).

#11  WAV-Datei Aufnahme mit 11kHz

Die Funktionen 1...19 dienen zum Einbinden von externen Programmen!

1.....9  FFT4WAVE beenden ohne die Daten abzuspeichern.
10...19  alle Daten in "TEMP.FFT" abspeichern und dann FFT4WAVE beenden.

FFT4WAVE liefert DOS die Funktionsnummer als Errorlevel zurück.
Der Errorlevel kann in der START.BAT Datei ausgewertet werden und startet
dann das gewünschte externe Programm.

Funktion Nr.11 startet ein externes Programm:     RWAVE fft.wav 11000

Dieses Programm nimmt die SOUND-Datei "FFT.WAV" auf, mit einer
Samplerate von 11000 1/s, was einer Grenzfrequenz von 5500Hz entspricht.

#12  WAV-Datei Aufnahme mit 22kHz

Die Funktionen 1...19 dienen zum Einbinden von externen Programmen!

1.....9  FFT4WAVE beenden ohne die Daten abzuspeichern.
10...19  alle Daten in "TEMP.FFT" abspeichern und dann FFT4WAVE beenden.

FFT4WAVE liefert DOS die Funktionsnummer als Errorlevel zurück.
Der Errorlevel kann in der START.BAT Datei ausgewertet werden und startet
dann das gewünschte externe Programm.

Funktion Nr.12 startet ein externes Programm:     RWAVE fft.wav 22000

Dieses Programm nimmt die SOUND-Datei "FFT.WAV" auf, mit einer
Samplerate von 22000 1/s, was einer Grenzfrequenz von 11000Hz entspricht.

#13  WAV-Datei Aufnahme mit 44kHz

Die Funktionen 1...19 dienen zum Einbinden von externen Programmen!

1.....9  FFT4WAVE beenden ohne die Daten abzuspeichern.
10...19  alle Daten in "TEMP.FFT" abspeichern und dann FFT4WAVE beenden.

FFT4WAVE liefert DOS die Funktionsnummer als Errorlevel zurück.
Der Errorlevel kann in der START.BAT Datei ausgewertet werden und startet
dann das gewünschte externe Programm.

Funktion Nr.13 startet ein externes Programm:     RWAVE fft.wav 44000

Dieses Programm nimmt die SOUND-Datei "FFT.WAV" auf, mit einer
Samplerate von 44000 1/s, was einer Grenzfrequenz von 22000Hz entspricht.

#8  Formeln...

Extern eingebundener Formel-Interpreter / Funktionsgenerator
-------------------------------------------------------------
Geben sie eine Gleichung der Form  'y=5*sin(x)-1' oder 'y=rect(t)+t' ein;
(das y= lassen Sie aber bitte weg!) und Sie erhalten die diskreten Werte...

Die Daten liegen in der FFT typischen Darstellung vor, mit der Null am linken
und rechten Rand (in X-Richtung), wenn Xmin als negative Zahl eingegeben wird!
Wenn Sie das stört, benutzen Sie doch einfach die Nullpunktvertauschung_X.

Es existieren folgende Variablen und Konstanten:
-------------------------------------------------
t = x           
e = 2.718281828
p = 3.141592654 = π
m = 6.283185307 = 2π
q = 9.869604401 = π²
l = 0.693147181 = ln(2) 
w = 1.414213562 = √2
v = 0.707106781 = 1/√2
d = 1.732050808 = √3

Funktionen:
------------

   sin()     cos()     tan()
Arcsin()  Arccos()  Arctan()
Si()      <== Si(x)=sin(x)/x 
ln()      <== Logarithmus zur Basis e
log()     <== Logarithmus zur Basis 10
Wurzel()  <== Quadratwurzel / Squareroot...
abs()     <== absoluter (Vorzeichenloser) Wert
sgn()     <== sgn(<0)=-1   sgn(0)=0   sgn(>0)=1
Sprung()  <== Sprung(>=0)=1        Sprung(<0)=0
clip()    <== clip(<-1)=-1   clip(x)=x   clip(>1)=1
noise(x)  <== Zufallszahl, von -x ... x 
data(x)   <== Zufallszahl, Werte = 0,1,2,3,4...x
rect()    <== rect(-0.5<x<0.5)=1              sonst 0
dreieck() <== dreieck(-1<x<1)=1-abs(x)        sonst 0
ramp()    <== ramp(-1<x<1)=0.5*x+0.5          sonst 0
Hanning() <== Hanning(-1<x<1)=0.5+0.5cos(π*x) sonst 0
diracs()  <== diracs(x=int(x)) = (1)          sonst 0
dirac()   <== dirac( x = 0 )   = (1)          sonst 0
exp()     <== exp(0<x) = e^(-ln(2)*x )        sonst 0
gauss(x)  <==            e^(-ln(2)*x²)

Natürlich ist die tatsächliche Programmierung teilweise stark abweichend, um
optimale (also zuverlässige Funktion) zu gewährleisten, gerade die korrekte
Funktion des Diracstoßes/Diracstoßfolge bei Faltungen, war nicht ganz einfach
zu realisieren, aber Ich habe es geschafft !!!

Folgende Operatoren gibt es:
------------------------------
 +   Addition
 -   Subtraktion
 *   Multiplikation
 /   Divison
 ^   Potenzieren, hoch
 #   Faltung  (Ich weiss daß das '*' eigentlich für die Faltung, und nicht für
               die Multiplikation steht, aber IBM wußte das wohl nicht...)

Der Faltungsoperator # ist nicht innerhalb von Klammern zulässig!!!
(Es sind aber durchaus mehere Faltungen, '#'s in einer Gleichung zulässig!)
Der Faltungsoperator # bewirkt, daß die Gleichung in mehrere Stücke geteilt
wird, die dann getrennt ausgerechnet werden, und schließlich mittels
FFT-Faltung miteinander gefaltet werden...

Ich bin auf die korrekte Funktion der Faltung sehr stolz.

Rangfolge der Operatoren:    1.Stufe    ( )           Klammern
                             2.Stufe    + - * / ^     gleichrangig!
                             3.Stufe    #             Faltung

Gleichrangige Operatoren werden stur von links nach rechts gerechnet.
Ich empfehle deshalb dringend die Verwendung von Klammern, Beispiel:
e*t-p^2*sin(t)  wird gerechnet wie [[[e*t]-p]^2]*sin(t)
(e*t)-((p^2)*sin(t)) dagegen bewirkt die korrekte mathematische Rangfolge...

Negative Zahlen: -z eingeben als (0-z)

Mit  'Esc'  wird der Funktions-Generator abgebrochen / abgewürgt !
Mit  'Del'  wird die angezeigte Funktion verworfen (also neue Formel eingeben).
Mit 'Enter' wird die angezeigte Funktion an FFT4WAVE über TEMP.FFT übergeben.
                   TEMP.FFT wird beim Start von FFT4WAVE automatisch geladen.

#40  alle Daten (.FFT)  laden

Zeigt alle FFT-Dateien des FFT4WAVE Verzeichnisses an.
Aus diesen Dateien müssen Sie eine auswählen, oder mit Esc abbrechen.
diese Datei wird dann geladen; *.FFT ist das eigentliche Datenformat von
FFT4WAVE, es enthält alle Informationen und alle Daten...


Das *.FFT Datenformat:
----------------------- 
long    Status
long    AnzahlNormal
long    AnzahlReal
long    AnzahlImag
double  Samplerate
double  real[]        //AnzahlReal double-Werte  {real[] Array} 
double  imag[]        //AnzahlImag double-Werte  {imag[] Array}


Status:  bit0 =  (Stereo)       reelle / komplexe Daten
         bit1 = (FFTflag)  Zeitbereich / Frequenzbereich
         bit2 =  (Nykill)  transformierte reelle Daten
         Daraus ergeben sich folgende sinnvolle Möglichkeiten:
Status= 0     Reelle Daten im Zeitbereich
Status= 1   Komplexe Daten im Zeitbereich
Status= 3   Komplexe Daten im Frequenzbereich, 0...Samplerate
Status= 7   Komplexe Daten im Frequenzbereich, 0...Samplerate/2

AnzahlNormal ist die Anzahl gültiger Abtastwerte (Daten):
Komplexen Daten:  AnzahlNormal = der kleinere Wert von AnzahlReal,AnzahlImag.
Reelle Daten:     AnzahlNormal = AnzahlReal + AnzahlImag;

Reelle Daten werden alternierend in real[] und imag[] abgespeichert:
real[] = { 0, 2, 4, 6, 8, 10, 12, 14, ...};
imag[] = { 1, 3, 5, 7, 9, 11, 13, 15, ...};
Die Zahlen entsprechen der Nummer des Reellen Wertes!

#41  alle Daten (.FFT)  speichern

Zeigt alle FFT-Dateien des FFT4WAVE Verzeichnisses an.
Geben Sie jetzt einen neuen Dateinamen an (.FFT können sie auch weglassen).
Alle Daten und Informationen werden jetzt in dieser FFT-Datei gespeichert!
*.FFT ist das eigentliche Datenformat von FFT4WAVE...


Das *.FFT Datenformat:
----------------------- 
long    Status
long    AnzahlNormal
long    AnzahlReal
long    AnzahlImag
double  Samplerate
double  real[]        //AnzahlReal double-Werte  {real[] Array} 
double  imag[]        //AnzahlImag double-Werte  {imag[] Array}


Status:  bit0 =  (Stereo)       reelle / komplexe Daten
         bit1 = (FFTflag)  Zeitbereich / Frequenzbereich
         bit2 =  (Nykill)  transformierte reelle Daten
         Daraus ergeben sich folgende sinnvolle Möglichkeiten:
Status= 0     Reelle Daten im Zeitbereich
Status= 1   Komplexe Daten im Zeitbereich
Status= 3   Komplexe Daten im Frequenzbereich, 0...Samplerate
Status= 7   Komplexe Daten im Frequenzbereich, 0...Samplerate/2

AnzahlNormal ist die Anzahl gültiger Abtastwerte (Daten):
Komplexen Daten:  AnzahlNormal = der kleinere Wert von AnzahlReal,AnzahlImag.
Reelle Daten:     AnzahlNormal = AnzahlReal + AnzahlImag;

Reelle Daten werden alternierend in real[] und imag[] abgespeichert:
real[] = { 0, 2, 4, 6, 8, 10, 12, 14, ...};
imag[] = { 1, 3, 5, 7, 9, 11, 13, 15, ...};
Die Zahlen entsprechen der Nummer des Reellen Wertes!

#42  Importiere als  Reell

Importiert Headerlose Zahlen, die als 'Text' , 'Float' oder 'Double' Format 
vorliegen, als reelle Daten im Zeitbereich.

Reelle Daten werden alternierend in real[] und imag[] abgespeichert:
real[] = { 0, 2, 4, 6, 8, 10, 12, 14, ...};
imag[] = { 1, 3, 5, 7, 9, 11, 13, 15, ...};
Die Zahlen entsprechen der Nummer des reellen Wertes!
Dadurch können doppelt soviele reelle Daten im Speicher gehalten werden,
außerdem ist es dadurch sehr einfach, reelle in komplexe Daten umzuwandeln,
man braucht einfach nur das imag[] Array mit Nullen zu überladen...

Zuerst müssen Sie sich für ein Format entscheiden (Text, Float, Double).
Daraufhin werden alle Dateien diesen Formats im FFT4WAVE-Directory angezeigt.
Dies ist die letzte Chance um Esc zu benutzen, andernfalls werden die Daten
geladen. Es können natürlich nur soviele Daten gelesen werden, wie im Rechner
Speicherplatz zur Verfügung steht, der Rest wird einfach ignoriert...


Text - Format:   *.(T)
-----------------------
Alle Dateien mit der Endung .(T) werden als Textformat interpretiert.
Das bedeutet, daß jede Zeile eine Zahl im Textformat enthält!
(hinter der Zahl darf sogar zusätzlich noch ein Kommentar stehen)
Als Zahl werden folgende Zeichen interpretiert:  1234567890. -e
Beispiele:  

   24        ;Dies ist ein Kommentar
  3.14159  
-0.75
 1.2345e-12  =  1.2345*10^-12 = 0.0000000000000012345  <--Kommentar
-1.7e6       = -1.7000*10^6   = 1700000.0              <--Kommentar
0
-234567.7578 = noch ein Kommentar



Float - Format:   *.(F)
------------------------
Alle Dateien mit der Endung .(F) werden als Floatformat interpretiert,
das sich aus den Floatformat (Gleitkomma) der Sprache C ergibt.
Selbiges entspricht einer internationalen Normung und ist 4 Bytes lang.
Die Float-Zahlen folgen ohne jedes Trennzeichen aufeinander, daraus folgt:
Anzahl Zahlen = Länge der Datei in Bytes / 4



Double - Format:   *.(D)
-------------------------
Alle Dateien mit der Endung .(D) werden als Doubleformat interpretiert,
das sich aus den Doubleformat (Gleitkomma) der Sprache C ergibt.
Selbiges entspricht einer internationalen Normung und ist 8 Bytes lang.
Die Double-Zahlen folgen ohne jedes Trennzeichen aufeinander, daraus folgt:
Anzahl Zahlen = Länge der Datei in Bytes / 8

(Dateien mit der Endung .FFT enthalten ebenfalls Zahlen im Double-Format,
 enthalten zusätzlich jedoch einen Header mit zusätzlichen Informationen.)

#43  Importiere als  Real

Importiert Headerlose Zahlen, die als 'Text' , 'Float' oder 'Double' Format 
vorliegen, als Realteil komplexer Daten im Zeitbereich.

Der Imaginärteil komplexer Daten wird dabei überhaupt nicht verändert!

Es kommt häufig vor,daß Realteil und Imaginärteil unterschiedliche Längen haben
können. Diese können sogar vollständig in einer *.FFT Datei gespeichert werden.
Es ist natürlich klar, daß für bestimmte Operationen, wie z.b.
Hanning Fenster, FFT, X-Skalierung, Y-Skalierung, Polar -> real & imag,
Nullpunktvertauschung_X, Absoluter Fehler, komplexe Faltung,
die Daten von Realteil und Imaginärteil existent sein müssen!
In diesem Fall wird die kürzere von beiden Längen als gültige Länge für die
auszuführende Operation verwendet. Diese wird auch unter Status-Information
gezeigt. Selbst Visualisierung zeigt nur bis zur gültigen Länge an!
Folgende Operationen korrigieren (kürzen) die überstehende Länge einfach weg:
FFT, X-Skalierung, Y-Skalierung, Absoluter Fehler, und die komplexe Faltung.

Der Vorteil der dynamischen Datenlänge:

fülle     Realteil mit  800 Werten
fülle Imaginärteil mit 1024 Werten   /gültige Länge=800
fülle Imaginärteil mit  512 Werten   /gültige Länge=512
fülle     Realteil mit 8192 Werten   /gültige Länge=512
fülle Imaginärteil mit 9000 Werten   /gültige Länge=8192


Zuerst müssen Sie sich für ein Format entscheiden (Text, Float, Double).
Daraufhin werden alle Dateien diesen Formats im FFT4WAVE-Directory angezeigt.
Dies ist die letzte Chance um Esc zu benutzen, andernfalls werden die Daten
geladen. Es können natürlich nur soviele Daten gelesen werden, wie im Rechner
Speicherplatz zur Verfügung steht, der Rest wird einfach ignoriert...


Text - Format:   *.(T)
-----------------------
Alle Dateien mit der Endung .(T) werden als Textformat interpretiert.
Das bedeutet, daß jede Zeile eine Zahl im Textformat enthält!
(hinter der Zahl darf sogar zusätzlich noch ein Kommentar stehen)
Als Zahl werden folgende Zeichen interpretiert:  1234567890. -e
Beispiele:  

   24        ;Dies ist ein Kommentar
  3.14159  
-0.75
 1.2345e-12  =  1.2345*10^-12 = 0.0000000000000012345  <--Kommentar
-1.7e6       = -1.7000*10^6   = 1700000.0              <--Kommentar
0
-234567.7578 = noch ein Kommentar



Float - Format:   *.(F)
------------------------
Alle Dateien mit der Endung .(F) werden als Floatformat interpretiert,
das sich aus den Floatformat (Gleitkomma) der Sprache C ergibt.
Selbiges entspricht einer internationalen Normung und ist 4 Bytes lang.
Die Float-Zahlen folgen ohne jedes Trennzeichen aufeinander, daraus folgt:
Anzahl Zahlen = Länge der Datei in Bytes / 4 



Double - Format:   *.(D)
-------------------------
Alle Dateien mit der Endung .(D) werden als Doubleformat interpretiert,
das sich aus den Doubleformat (Gleitkomma) der Sprache C ergibt.
Selbiges entspricht einer internationalen Normung und ist 8 Bytes lang.
Die Double-Zahlen folgen ohne jedes Trennzeichen aufeinander, daraus folgt:
Anzahl Zahlen = Länge der Datei in Bytes / 8 

(Dateien mit der Endung .FFT enthalten ebenfalls Zahlen im Double-Format,
 enthalten zusätzlich jedoch einen Header mit zusätzlichen Informationen.)

#44  Importiere als  Imag.

Importiert Headerlose Zahlen, die als 'Text' , 'Float' oder 'Double' Format 
vorliegen, als Imaginärteil komplexer Daten im Zeitbereich.

Der Realteil komplexer Daten wird dabei überhaupt nicht verändert!

Es kommt häufig vor,daß Realteil und Imaginärteil unterschiedliche Längen haben
können. Diese können sogar vollständig in einer *.FFT Datei gespeichert werden.
Es ist natürlich klar,daß für bestimmte Operationen, wie z.b.
Hanning Fenster, FFT, X-Skalierung, Y-Skalierung, Polar -> real & imag,  
Nullpunktvertauschung_X, Absoluter Fehler, komplexe Faltung,
die Daten von Realteil und Imaginärteil existent sein müssen!
In diesem Fall wird die kürzere von beiden Längen als gültige Länge für die
auszuführende Operation verwendet. Diese wird auch unter Status-Information 
gezeigt. Selbst Visualisierung zeigt nur bis zur gültigen Länge an!
Folgende Operationen korrigieren (kürzen) die überstehende Länge einfach weg:
FFT, X-Skalierung, Y-Skalierung, Absoluter Fehler, und die komplexe Faltung.

Der Vorteil der dynamischen Datenlänge:

fülle     Realteil mit  800 Werten
fülle Imaginärteil mit 1024 Werten   /gültige Länge=800
fülle Imaginärteil mit  512 Werten   /gültige Länge=512
fülle     Realteil mit 8192 Werten   /gültige Länge=512
fülle Imaginärteil mit 9000 Werten   /gültige Länge=8192

Tip: Es ist sehr sehr einfach reelle im komplexe Daten umzuwandeln,
man braucht einfach nur ZERO.(F) als Imaginärteil zu (über)laden.
Es ist aber auch möglich, die reellen Daten zu exportieren, dann als
Realteil zu importieren und schließlich ZERO.(F) als Imaginärteil zu laden.


Zuerst müssen Sie sich für ein Format entscheiden (Text, Float, Double).
Daraufhin werden alle Dateien diesen Formats im FFT4WAVE-Directory angezeigt.
Dies ist die letzte Chance um Esc zu benutzen, andernfalls werden die Daten
geladen. Es können natürlich nur soviele Daten gelesen werden, wie im Rechner
Speicherplatz zur Verfügung steht, der Rest wird einfach ignoriert...


Text - Format:   *.(T)
-----------------------
Alle Dateien mit der Endung .(T) werden als Textformat interpretiert.
Das bedeutet, daß jede Zeile eine Zahl im Textformat enthält!
(hinter der Zahl darf sogar zusätzlich noch ein Kommentar stehen)
Als Zahl werden folgende Zeichen interpretiert:  1234567890. -e
Beispiele:  

   24        ;Dies ist ein Kommentar
  3.14159  
-0.75
 1.2345e-12  =  1.2345*10^-12 = 0.0000000000000012345  <--Kommentar
-1.7e6       = -1.7000*10^6   = 1700000.0              <--Kommentar
0
-234567.7578 = noch ein Kommentar



Float - Format:   *.(F)
------------------------
Alle Dateien mit der Endung .(F) werden als Floatformat interpretiert,
das sich aus den Floatformat (Gleitkomma) der Sprache C ergibt.
Selbiges entspricht einer internationalen Normung und ist 4 Bytes lang.
Die Float-Zahlen folgen ohne jedes Trennzeichen aufeinander, daraus folgt:
Anzahl Zahlen = Länge der Datei in Bytes / 4 



Double - Format:   *.(D)
-------------------------
Alle Dateien mit der Endung .(D) werden als Doubleformat interpretiert,
das sich aus den Doubleformat (Gleitkomma) der Sprache C ergibt.
Selbiges entspricht einer internationalen Normung und ist 8 Bytes lang.
Die Double-Zahlen folgen ohne jedes Trennzeichen aufeinander, daraus folgt:
Anzahl Zahlen = Länge der Datei in Bytes / 8 

(Dateien mit der Endung .FFT enthalten ebenfalls Zahlen im Double-Format,
 enthalten zusätzlich jedoch einen Header mit zusätzlichen Informationen.)

#45  Importiere als  Real & Imag.

Importiert Headerlose Zahlen, die als 'Text' , 'Float' oder 'Double' Format 
vorliegen, als komplexe Daten (Real & Imag.) im Zeitbereich.
Dazu wird die Anzahl der Zahlen bestimmt, 

       0 ... Anzahl/2-1        realen Daten, Realteil
Anzahl/2 ... Anzahl-1      imaginären Daten, Imaginärteil

also wird die erste Hälfte als Real und die zweite Hälfte als Imag. eingelesen.

Zuerst müssen Sie sich für ein Format entscheiden (Text, Float, Double).
Daraufhin werden alle Dateien diesen Formats im FFT4WAVE-Directory angezeigt.
Dies ist die letzte Chance um Esc zu benutzen, andernfalls werden die Daten
geladen. Wenn nicht genug Speicherplatz zur Verfügung steht, dann stehen im
Imaginärteil unsinnige Daten, der Rechner stürzt jedoch keinesfalls ab!
Das Problem tritt jedoch eigentlich so gut wie nie auf!!!



Text - Format:   *.(T)
-----------------------
Alle Dateien mit der Endung .(T) werden als Textformat interpretiert.
Das bedeutet, daß jede Zeile eine Zahl im Textformat enthält!
(hinter der Zahl darf sogar zusätzlich noch ein Kommentar stehen)
Als Zahl werden folgende Zeichen interpretiert:  1234567890. -e
Beispiele:  

   24        ;Dies ist ein Kommentar
  3.14159  
-0.75
 1.2345e-12  =  1.2345*10^-12 = 0.0000000000000012345  <--Kommentar
-1.7e6       = -1.7000*10^6   = 1700000.0              <--Kommentar
0
-234567.7578 = noch ein Kommentar



Float - Format:   *.(F)
------------------------
Alle Dateien mit der Endung .(F) werden als Floatformat interpretiert,
das sich aus den Floatformat (Gleitkomma) der Sprache C ergibt.
Selbiges entspricht einer internationalen Normung und ist 4 Bytes lang.
Die Float-Zahlen folgen ohne jedes Trennzeichen aufeinander, daraus folgt:
Anzahl Zahlen = Länge der Datei in Bytes / 4 



Double - Format:   *.(D)
-------------------------
Alle Dateien mit der Endung .(D) werden als Doubleformat interpretiert,
das sich aus den Doubleformat (Gleitkomma) der Sprache C ergibt.
Selbiges entspricht einer internationalen Normung und ist 8 Bytes lang.
Die Double-Zahlen folgen ohne jedes Trennzeichen aufeinander, daraus folgt:
Anzahl Zahlen = Länge der Datei in Bytes / 8 

(Dateien mit der Endung .FFT enthalten ebenfalls Zahlen im Double-Format,
 enthalten zusätzlich jedoch einen Header mit zusätzlichen Informationen.)

#46  exportiere     Alles

Exportiert (speichert) alle vorhandenen Daten (Reell oder Komplex), als  
Headerlose Zahlen hintereinander, im 'Text' , 'Float' oder 'Double' Format.
Es spielt keine Rolle, ob die Daten im Zeitbereich oder im Frequenzbereich
vorliegen, denn die Information Zeitbereich/Frequenzbereich, Samplerate,
Datenlänge, Komplex/Reell wird nicht mit abgespeichert (Headerless).
Es werden nur die rohen Zahlen abgespeichert...

Wenn komplexe Daten vorliegen wird zuerst der     Realteil bis zur gültigen 
Datenlänge abgespeichert, und dann  wird  der Imaginärteil bis zur gültigen
Datenlänge abgespeichert.

Reelle Daten werden einfach hintereinander abgespeichert.
(also nicht alternierend in Realteil & Imaginärteil wie im *.FFT Format)

Zuerst müssen Sie sich für ein Format entscheiden (Text, Float, Double).
Dies ist die letze Chance um ESC zu benutzen um die Funktion abzubrechen!
Daraufhin werden alle Dateien diesen Formats im FFT4WAVE-Directory angezeigt.
Nun müssen sie einen neuen Dateinamen eingeben, die richtige Endung wird 
anhand des gewählten Formats (Text, Float, Double) automatisch angehängt.



Text - Format:   *.(T)
-----------------------
Alle Dateien mit der Endung .(T) werden als Textformat interpretiert.
Das bedeutet, daß jede Zeile eine Zahl im Textformat enthält!
(hinter der Zahl darf sogar zusätzlich noch ein Kommentar stehen)
Als Zahl werden folgende Zeichen interpretiert:  1234567890. -e
Beispiele:  

   24        ;Dies ist ein Kommentar
  3.14159  
-0.75
 1.2345e-12  =  1.2345*10^-12 = 0.0000000000000012345  <--Kommentar
-1.7e6       = -1.7000*10^6   = 1700000.0              <--Kommentar
0
-234567.7578 = noch ein Kommentar



Float - Format:   *.(F)
------------------------
Alle Dateien mit der Endung .(F) werden als Floatformat interpretiert,
das sich aus den Floatformat (Gleitkomma) der Sprache C ergibt.
Selbiges entspricht einer internationalen Normung und ist 4 Bytes lang.
Die Float-Zahlen folgen ohne jedes Trennzeichen aufeinander, daraus folgt:
Anzahl Zahlen = Länge der Datei in Bytes / 4 



Double - Format:   *.(D)
-------------------------
Alle Dateien mit der Endung .(D) werden als Doubleformat interpretiert,
das sich aus den Doubleformat (Gleitkomma) der Sprache C ergibt.
Selbiges entspricht einer internationalen Normung und ist 8 Bytes lang.
Die Double-Zahlen folgen ohne jedes Trennzeichen aufeinander, daraus folgt:
Anzahl Zahlen = Länge der Datei in Bytes / 8 

(Dateien mit der Endung .FFT enthalten ebenfalls Zahlen im Double-Format,
 enthalten zusätzlich jedoch einen Header mit zusätzlichen Informationen.)


#47  exportiere nur Real

Exportiert (speichert) nur den Realteil von komplexen Daten als
Headerlose Zahlen hintereinander, im 'Text' , 'Float' oder 'Double' Format.
Es spielt keine Rolle, ob die Daten im Zeitbereich oder im Frequenzbereich
vorliegen, denn die Information Zeitbereich/Frequenzbereich, Samplerate,
Datenlänge, Komplex/Reell wird nicht mit abgespeichert (Headerless).
Es werden nur die rohen Zahlen abgespeichert...

Sollten unsinnigerweise reelle Daten vorliegen, 
dann wird zwar nach dem Dateinamen gefragt, es wird aber nichts
in der Datei abgespeichert, sondern nur eine leere Datei erzeugt!

Zuerst müssen Sie sich für ein Format entscheiden (Text, Float, Double).
Dies ist die letze Chance um ESC zu benutzen um die Funktion abzubrechen!
Daraufhin werden alle Dateien diesen Formats im FFT4WAVE-Directory angezeigt.
Nun müssen sie einen neuen Dateinamen eingeben, die richtige Endung wird 
anhand des gewählten Formats (Text, Float, Double) automatisch angehängt.



Text - Format:   *.(T)
-----------------------
Alle Dateien mit der Endung .(T) werden als Textformat interpretiert.
Das bedeutet, daß jede Zeile eine Zahl im Textformat enthält!
(hinter der Zahl darf sogar zusätzlich noch ein Kommentar stehen)
Als Zahl werden folgende Zeichen interpretiert:  1234567890. -e
Beispiele:

   24        ;Dies ist ein Kommentar
  3.14159  
-0.75
 1.2345e-12  =  1.2345*10^-12 = 0.0000000000000012345  <--Kommentar
-1.7e6       = -1.7000*10^6   = 1700000.0              <--Kommentar
0
-234567.7578 = noch ein Kommentar



Float - Format:   *.(F)
------------------------
Alle Dateien mit der Endung .(F) werden als Floatformat interpretiert,
das sich aus den Floatformat (Gleitkomma) der Sprache C ergibt.
Selbiges entspricht einer internationalen Normung und ist 4 Bytes lang.
Die Float-Zahlen folgen ohne jedes Trennzeichen aufeinander, daraus folgt:
Anzahl Zahlen = Länge der Datei in Bytes / 4 



Double - Format:   *.(D)
-------------------------
Alle Dateien mit der Endung .(D) werden als Doubleformat interpretiert,
das sich aus den Doubleformat (Gleitkomma) der Sprache C ergibt.
Selbiges entspricht einer internationalen Normung und ist 8 Bytes lang.
Die Double-Zahlen folgen ohne jedes Trennzeichen aufeinander, daraus folgt:
Anzahl Zahlen = Länge der Datei in Bytes / 8 

(Dateien mit der Endung .FFT enthalten ebenfalls Zahlen im Double-Format,
 enthalten zusätzlich jedoch einen Header mit zusätzlichen Informationen.)


#48  exportiere nur Imaginär

Exportiert (speichert) nur den Imaginärteil von komplexen Daten als
Headerlose Zahlen hintereinander, im 'Text' , 'Float' oder 'Double' Format.
Es spielt keine Rolle, ob die Daten im Zeitbereich oder im Frequenzbereich
vorliegen, denn die Information Zeitbereich/Frequenzbereich, Samplerate,
Datenlänge, Komplex/Reell wird nicht mit abgespeichert (Headerless).
Es werden nur die rohen Zahlen abgespeichert...

Sollten unsinnigerweise reelle Daten vorliegen, 
dann wird zwar nach dem Dateinamen gefragt, es wird aber nichts
in der Datei abgespeichert, sondern nur eine leere Datei erzeugt!

Zuerst müssen Sie sich für ein Format entscheiden (Text, Float, Double).
Dies ist die letze Chance um ESC zu benutzen um die Funktion abzubrechen!
Daraufhin werden alle Dateien diesen Formats im FFT4WAVE-Directory angezeigt.
Nun müssen sie einen neuen Dateinamen eingeben, die richtige Endung wird
anhand des gewählten Formats (Text, Float, Double) automatisch angehängt.



Text - Format:   *.(T)
-----------------------
Alle Dateien mit der Endung .(T) werden als Textformat interpretiert.
Das bedeutet, daß jede Zeile eine Zahl im Textformat enthält!
(hinter der Zahl darf sogar zusätzlich noch ein Kommentar stehen)
Als Zahl werden folgende Zeichen interpretiert:  1234567890. -e
Beispiele:  

   24        ;Dies ist ein Kommentar
  3.14159  
-0.75
 1.2345e-12  =  1.2345*10^-12 = 0.0000000000000012345  <--Kommentar
-1.7e6       = -1.7000*10^6   = 1700000.0              <--Kommentar
0
-234567.7578 = noch ein Kommentar



Float - Format:   *.(F)
------------------------
Alle Dateien mit der Endung .(F) werden als Floatformat interpretiert,
das sich aus den Floatformat (Gleitkomma) der Sprache C ergibt.
Selbiges entspricht einer internationalen Normung und ist 4 Bytes lang.
Die Float-Zahlen folgen ohne jedes Trennzeichen aufeinander, daraus folgt:
Anzahl Zahlen = Länge der Datei in Bytes / 4



Double - Format:   *.(D)
-------------------------
Alle Dateien mit der Endung .(D) werden als Doubleformat interpretiert,
das sich aus den Doubleformat (Gleitkomma) der Sprache C ergibt.
Selbiges entspricht einer internationalen Normung und ist 8 Bytes lang.
Die Double-Zahlen folgen ohne jedes Trennzeichen aufeinander, daraus folgt:
Anzahl Zahlen = Länge der Datei in Bytes / 8 

(Dateien mit der Endung .FFT enthalten ebenfalls Zahlen im Double-Format,
 enthalten zusätzlich jedoch einen Header mit zusätzlichen Informationen.)


#37  Hilfe (Wichtig)
Benutzen Sie bitte die Maus, um sich den ganzen Text anzusehen (scrolling).

Das Programm läßt sich fast vollständig mit der Maus bedienen.
Die linke Maus-Taste startet meistens ein Funktion,
und die Rechte Maus-Taste hat im Menü die Funktion,
die kontextsensitive Hilfe abzurufen, genau so wie die 'F1' Taste.

Die 'Esc' Taste bricht Funktionen ab (inclusive UNDO).
Praktisch alle Funktionen des Menus können bis zum letzten Moment mit der 'Esc'
Taste abgebrochen werden, ohne daß sich die Daten verändern!

Ich empfehle dringend, daß Durchlesen der kontextsensitiven Hilfen.
Andernfalls dürften Sie wirklich Schwierigkeiten haben,
das Programm effektiv und sinnvoll zu nutzen...

START!.BAT   --->  startet FFT4WAVE
FARBEN.EXE   --->  zeigt all 16 VGA Farben...
FORMEL.EXE   --->  externer Funktionsgenerator von FFT4WAVE
FILTERS.EXE  --->  erzeugt langsam 4MB Beispiele und Filter!
RWAVE.EXE    --->  Aufnahme von TEMP.WAV mit Soundblaster_8bit, (DMA=1, 220h)
RWAVE kann durch WAV-Aufnahmeprogramme für GUS/PAS/SB16/AWE32 ersetzt werden,
dazu braucht man lediglich START!.BAT zu ändern.


FFT4WAVE läuft unter DOS, PTS_DOS, Novell_DOS, Windows, OS/2, Chicago...
Es benötigt einen 286 Prozessor (Coprozessor kann auch emuliert werden),
500k bis 640k RAM, eine Maus, und einen Diskcache mit mindestens 512k RAM !!!
Folgende 16_Farben Grafikmodi werden über VESA-Treiber unterstützt:
640x480,  800x600,  1024x768.


Das Programm arbeitet Puffer orientiert, vergleichbar mit VGA-COPY.
Das bedeutet, daß die Gesamtheit der Daten den Puffer darstellt.
Jede Funktion macht irgend etwas mit den Daten im Puffer, der aus dem
real[] Array (Realteil) und dem imag[] Array (Imaginärteil) besteht.
(Reelle Daten werden alternierend in real[] und imag[] abgelegt.)
Der Puffer, (also die Daten) können verschiedene Zustände annehmen,
z.b. Zeitbereich, Frequenzbereich, Reell, Komplex, ...
Durch die Samplerate ist es möglich, die Daten korrekt skaliert (in X-Richtung)
mit Hilfe der Visualisierung darzustellen. Es ist sogar möglich, in die
Daten hinein zu zoomen, um interessante Details besser betrachten zu können.

Außerdem besteht die Möglichkeit, den Grafikbildschirm in eine schwarzweiße
Windows 3.0 Bitmap-Datei zu schreiben (funktioniert auch mit Windows 3.1).
Dazu müssen sie nur auf die 'F9' oder 'F10' Taste drücken.
Diese Bitmaps werden als  38k...98k  große BILD_???.BMP Datei gespeichert,
??? ist eine durchlaufende Nummer von 001 bis 999.

Die FFT4WAVE.INI Datei ist sehr wichtig und kann mit jedem Texteditor (ASCII)
ediert werden, sie enthält die Farbpalette, SETUP Informationen, und die
Menü-Struktur. Es ist also sogar möglich, den Menütext zu ändern,
ohne das Programm neu compilieren zu müssen!
(Die kontextsensitive Hilfe Datei 'FFT4WAVE.HLP' hat dieselbe 'Menü-Struktur';
 allerdings etwas einfacher, also ohne Spaltenüberschriften.)
-------------------------------------------------------------------------------
Die FFT4WAVE.INI Datei beginnt mit 20 Farben,in 20 aufeinanderfolgenden Zeilen,
gefolgt von Kommentartexten. Die letzten drei 'Farben' , sind eigentlich keine
Farben, sondern erfüllen andere Funktionen:

'Farbe 17' legt fest wieviele Abtastwerte aus Sounddateien gelesen werden,
'Farbe 18' bestimmt dabei die Samplerate für unbekannte Sounddatei Formate.
'Farbe 19' bestimmt ob erweiterte Hilfen im Grafikmodus angezeigt werden
           müssen (1) (2), oder nicht (0). Die Modi (2) und (0) verwenden
           überigens meinen Schreibschriftzeichensatz...

Die darauf folgende Zeile enthält dann den Grafikmodus:
1 = 640x480,   2 = 800x600,   3 = 1024x768.
Voreingestellt ist 640x480 in 16 Farben, ändern Sie den Grafikmodus nur,
wenn ihre Grafikkarte und ihr Monitor diese SVGA-Modi auch unterstützen,
eventuell hilft ihnen die Verwendung eines VESA-Treibers weiter...

Die darauf folgenden Zeilen enthalten nun die Menü-Struktur:
Es stehen maximal 9 Spalten mal 24 Zeilen zur Verfügung, FFT4WAVE
erkennt freundlichweise selbst, wieviel Spalten und Zeilen vorliegen.
Sie müssen nur darauf achten, daß Sie nicht mehr als 9 Spalten und
auch nicht mehr als 24 Zeilen pro Spalte eingeben.
Die einzelnen Spalten dürfen unterschiedlich viele Zeilen enthalten.
FFT4WAVE's voreingestellte Menü-Struktur nutzt bisher erst 2 Spalten.
Jede neue Spalte beginnt mit einer Spaltenüberschrift,
darauf folgen dann die Zeilen. Um Spaltenüberschriften und Zeilen der Spalte
unterscheiden zu können, beginnen die Zeilen mit einem vorangestellten '#'.

Beispiel:     ┌──────────────────────────────────────┐
              │Dies ist eine Spaltenüberschrift      │
              │#FunktionsNummer  Funktionsname       │
              │#34               Das ist eine Zeile  │
              │#9                schnell beenden!    │
              │#19               beenden!            │
              │Und jetzt kommt die nächste Spalte... │
              │#11               Aufnahme 11kHz      │
              │#8                Formel eingeben     │
              └──────────────────────────────────────┘

Der Funktionsname wird im Menü angezeigt, die FunktionsNummer bestimmt jedoch
welche Funktion tatsächlich ausgeführt wird!

Der Sinn der Menü-Struktur ist, daß man lediglich einen Texteditor benötigt,
um das Programm an eine beliebige Fremdsprache anzupassen, außerdem kann man
unerwünschte Funktionen sogar abschalten...

Ich würde mich sehr freuen,
wenn User mit Fremdsprachenkenntnissen, Versionen von FFT4WAVE,
für entsprechende Fremdsprachen veröffentlichen würden,
denn ich selbst habe schon mit Englisch so meine Probleme...
Sie dürfen FFT4WAVE kommerziell nutzen, aber nicht kommerziell vermarkten,
wer also mein Programm für mehr als 20,-DM verkauft, der macht sich strafbar!
Dieses Preislimit gilt jedoch nicht für CD-ROM Programmsammelungen...
Ich habe nichts dagegen, wenn Sie eine verbesserte Version meines Programms
veröffentlichen, der Hinweis auf mich als Autor muß jedoch erhalten bleiben,
Sie können sich lediglich als Zweit-Autor dazu eintragen!

Lars Otte  (DrCaos)
#9   schnell Beenden!
Beendet FFT4WAVE ohne die Daten zu speichern!
#19  Exit/Beenden! 
Speichert alle Daten in "TEMP.FFT" und beendet dann FFT4WAVE.
(Wenn FFT4WAVE gestartet wird, dann wird automatisch "TEMP.FFT" geladen!)
#21  Eingabe mit Filtertyp Digital

Eingabe des Signals mit Hilfe der Maus.
(Mit der Maus kann man Linien ziehen und Punkte setzen!)
Fehlende Punkte werden mit einem digitalen Interpolations-Filter errechnet,
dieser Filter wiederholt einfach den letzten gültigen Wert, wenn Punkte fehlen.
Er eignet sich hervoragend zur Erstellung digitaler Signale.

Nach dem Start der Eingabe stehen folgende Tasten zur Verfügung:
----------------------------------------------------------------
Esc               Eingabe abbrechen
Del               Bildschirm löschen, Gitter/DIV zeichnen, und wieder Eingabe
Enter             eingebene Stützstellen & Linien akzeptieren, fortsetzen
rechte Maustaste  eingebene Stützstellen & Linien akzeptieren, fortsetzen 
linke  Maustaste  setzt Stützpunkte, Linie = Taste drücken und Maus bewegen
F9                Bildschirminhalt in BILD_???.BMP schreiben, (zum Drucken)
F10               wie F9, jedoch Farbe[2] gestrichelt darstellen
R                 zeigt den     Realteil maximiert in Farbe[3] am Bildschirm
I                 zeigt den Imaginärteil maximiert in Farbe[3] am Bildschirm
B                 zeigt den Real-und Imaginärteil maximiert in Farbe[3]

Nachdem nun die Stützstellen eingeben wurden, und mit 'Enter' bestätigt wurden,
werden die fehlenden Stützstellen mit dem Interpolations-Filter interpoliert.
Dann wird das Ergebnis der Interpolation gezeigt, und man kann mittels F9 / F10
das Ergebnis der Interpolation als Windows 3.0 BMP-Datei abspeichern.
(Die BILD_???.BMP Dateien werden von 001 bis 999 durchnummeriert.)

Nun stehen folgende Tasten zur Verfügung:
-----------------------------------------
Esc                 Eingabe  abbrechen
1                   RC-Glättungsfilter Stärke 1
2                   RC-Glättungsfilter Stärke 2
3                   RC-Glättungsfilter Stärke 3
4                   RC-Glättungsfilter Stärke 4
5                   RC-Glättungsfilter Stärke 5
6                   RC-Glättungsfilter Stärke 6 
7                   Symetrischer-Glättungsfilter Stärke 1
8                   Symetrischer-Glättungsfilter Stärke 2
9                   Symetrischer-Glättungsfilter Stärke 3
0                   Symetrischer-Glättungsfilter Stärke 4
andere Tasten       Gleichanteil = 0, fortsetzen...
linke  Maustaste    Gleichanteil = 0, fortsetzen...
rechte Maustaste    Eingabe des Nullpegels und dann fortsetzen...

Eingabe des Nullpegels (+ Drehung):
Der Nullpegel wird durch eine Linie zwischen zwei Punkten dargestellt,
haben beide Punkte eine unterschiedliche Höhe, erfolgt zusätzlich eine Drehung.
Die Eingabe des  ersten Punktes erfolgt durch drücken der rechten Maustaste,
die Eingabe des zweiten Punktes erfolgt durch drücken einer beliebigen Taste.


Die Filter sind 1.Ordnung,aber durch mehrmaliges filtern entstehen auch Filter
beliebiger Ordnung. Je größer die Stärke des Glättungsfilters, desto kleiner
ist die Grenzfrequenz des äquivalenten Tiefpasses.
Mit jedem Filtern erhöht sich auch die Spline-Ordnung des Signals...

RC-Filter:
----------
Es wird eine Mittelung über eine durch die Stärke bestimmte Breite ausgeführt,
außerdem liegt eine Rückkoppelung vor, die dem Bildungsgesetz der Zahl e
nicht unähnlich ist, wenn Sprünge im Signal vorliegen...
Es dürfte infolge dessen nicht wundern, daß Rechteckimpulsen die exp()-Funktion
aufgeprägt wird, genauso wie bei einem RC-Tiefpass 1.Ordnung.
Infolge dessen gehe ich davon aus, daß dieses Filter sich auch so ähnlich wie
ein RC-Tiefpass 1.Ordnung verhält...

Symetrischer Filter:
--------------------
Es wird eine Vorwärts-Mittelung des Signals, mit einer durch die Stärke 
bestimmten Breite ausgeführt, ohne Rückkoppelung! 
Die Vorwärts-Mittelung hat den Nachteil einer Verschiebung in X-Richtung,
um zu verhindern, daß unser Signal bei mehreren Filterungen vom Bildschirm
wandert, wird abwechselnd nach links und nach rechts gemittelt.
Aufgrund der Ähnlichkeit von Integration und Mittelung über eine begrenzte
Breite, kann davon ausgegangen werden,daß dieser Filter ein entfernter
Verwandter des Integrators ist(der Frequenzverlauf entspricht der Si-Funktion).
Rechteck und andere Signale, werden im Gegensatz zum RC-Filter symetrisch
verrundet, daher der Name 'Symetrischer Glättungsfilter'.


Nachdem wir nun gefiltert haben (oder auch nicht),
den Nullpegel festgelegt haben  (b.z.w. Gleichanteil = 0),
möchte das Programm gerne wissen wo, und wie es denn nun das Signal 
abzulegen hat, dies ist überigens die letzte Chance, um mit Esc abzubrechen!

Das Signal kann als reelle Daten im Speicher abgelegt werden,
oder als Realteil / Imaginärteil komplexer Daten.

Wollen wir Polare Daten eingeben,
speichern wir den Betrag als Realteil, und die Phase als Imaginärteil,
danach müssen wir noch von Polar nach Real & Imag. umrechnen...

#22  Eingabe mit Filtertyp Linear

Eingabe des Signals mit Hilfe der Maus.
(Mit der linken Maustaste kann man Linien ziehen und Punkte setzen!)
Fehlende Punkte werden mit einem linearer Interpolations-Filter errechnet,
wenn Punkte fehlen, werden einfach die existierenden Punkte durch Linien
miteinander verbunden. Aufgrund der hohen Geschwindigkeit wird diese
Interpolationsmethode gerne in Echtzeitanwendungen verwendet.

Nach dem Start der Eingabe stehen folgende Tasten zur Verfügung:
----------------------------------------------------------------
Esc               Eingabe abbrechen
Del               Bildschirm löschen, Gitter/DIV zeichnen, und wieder Eingabe
Enter             eingebene Stützstellen & Linien akzeptieren, fortsetzen
rechte Maustaste  eingebene Stützstellen & Linien akzeptieren, fortsetzen 
linke  Maustaste  setzt Stützpunkte, Linie = Taste drücken und Maus bewegen
F9                Bildschirminhalt in BILD_???.BMP schreiben, (zum Drucken)
F10               wie F9, jedoch Farbe[2] gestrichelt darstellen
R                 zeigt den     Realteil maximiert in Farbe[3] am Bildschirm
I                 zeigt den Imaginärteil maximiert in Farbe[3] am Bildschirm
B                 zeigt den Real-und Imaginärteil maximiert in Farbe[3]

Nachdem nun die Stützstellen eingeben wurden, und mit 'Enter' bestätigt wurden,
werden die fehlenden Stützstellen mit dem Interpolations-Filter interpoliert.
Dann wird das Ergebnis der Interpolation gezeigt, und man kann mittels F9 / F10
das Ergebnis der Interpolation als Windows 3.0 BMP-Datei abspeichern.
(Die BILD_???.BMP Dateien werden von 001 bis 999 durchnummeriert.)

Nun stehen folgende Tasten zur Verfügung:
-----------------------------------------
Esc                 Eingabe  abbrechen
1                   RC-Glättungsfilter Stärke 1
2                   RC-Glättungsfilter Stärke 2
3                   RC-Glättungsfilter Stärke 3
4                   RC-Glättungsfilter Stärke 4
5                   RC-Glättungsfilter Stärke 5
6                   RC-Glättungsfilter Stärke 6 
7                   Symetrischer-Glättungsfilter Stärke 1
8                   Symetrischer-Glättungsfilter Stärke 2
9                   Symetrischer-Glättungsfilter Stärke 3
0                   Symetrischer-Glättungsfilter Stärke 4
andere Tasten       Gleichanteil = 0, fortsetzen...
linke  Maustaste    Gleichanteil = 0, fortsetzen...
rechte Maustaste    Eingabe des Nullpegels und dann fortsetzen...

Eingabe des Nullpegels (+ Drehung):
Der Nullpegel wird durch eine Linie zwischen zwei Punkten dargestellt,
haben beide Punkte eine unterschiedliche Höhe, erfolgt zusätzlich eine Drehung.
Die Eingabe des  ersten Punktes erfolgt durch drücken der rechten Maustaste,
die Eingabe des zweiten Punktes erfolgt durch drücken einer beliebigen Taste.


Die Filter sind 1.Ordnung,aber durch mehrmaliges filtern entstehen auch Filter
beliebiger Ordnung. Je größer die Stärke des Glättungsfilters, desto kleiner 
ist die Grenzfrequenz des äquivalenten Tiefpasses.
Mit jedem Filtern erhöht sich auch die Spline-Ordnung des Signals...

RC-Filter:
----------
Es wird eine Mittelung über eine durch die Stärke bestimmte Breite ausgeführt,
außerdem liegt eine Rückkoppelung vor, die dem Bildungsgesetz der Zahl e
nicht unähnlich ist, wenn Sprünge im Signal vorliegen...
Es dürfte infolge dessen nicht wundern, daß Rechteckimpulsen die exp()-Funktion
aufgeprägt wird, genauso wie bei einem RC-Tiefpass 1.Ordnung.
Infolge dessen gehe ich davon aus, daß dieses Filter sich auch so ähnlich wie
ein RC-Tiefpass 1.Ordnung verhält...

Symetrischer Filter:
--------------------
Es wird eine Vorwärts-Mittelung des Signals, mit einer durch die Stärke 
bestimmten Breite ausgeführt, ohne Rückkoppelung! 
Die Vorwärts-Mittelung hat den Nachteil einer Verschiebung in X-Richtung,
um zu verhindern, daß unser Signal bei mehreren Filterungen vom Bildschirm
wandert, wird abwechselnd nach links und nach rechts gemittelt.
Aufgrund der Ähnlichkeit von Integration und Mittelung über eine begrenzte
Breite, kann davon ausgegangen werden, daß dieser Filter ein entfernter
Verwandter des Integrators ist(der Frequenzverlauf entspricht der Si-Funktion).     
Rechteck und andere Signale, werden im Gegensatz zum RC-Filter symetrisch
verrundet, daher der Name 'Symetrischer Glättungsfilter'.


Nachdem wir nun gefiltert haben (oder auch nicht),
den Nullpegel festgelegt haben  (b.z.w. Gleichanteil = 0),
möchte das Programm gerne wissen wo, und wie es denn nun das Signal 
abzulegen hat, dies ist überigens die letzte Chance, um mit Esc abzubrechen!

Das Signal kann als reelle Daten im Speicher abgelegt werden,
oder als Realteil / Imaginärteil komplexer Daten.

Wollen wir Polare Daten eingeben, 
speichern wir den Betrag als Realteil, und die Phase als Imaginärteil,
danach müssen wir noch von Polar nach Real & Imag. umrechnen...

#23  Eingabe mit Filtertyp SIN-Treppe

Eingabe des Signals mit Hilfe der Maus.
(Mit der Maus kann man Linien ziehen und Punkte setzen!)
Fehlende Punkte werden mit einem COS-Halbbogen Interpolations-Filter errechnet,
wenn Punkte fehlen, werden die existierenden Punkte durch einen COS-Halbbogen
miteinander verbunden. 

Nach dem Start der Eingabe stehen folgende Tasten zur Verfügung:
----------------------------------------------------------------
Esc               Eingabe abbrechen
Del               Bildschirm löschen, Gitter/DIV zeichnen, und wieder Eingabe
Enter             eingebene Stützstellen & Linien akzeptieren, fortsetzen
rechte Maustaste  eingebene Stützstellen & Linien akzeptieren, fortsetzen 
linke  Maustaste  setzt Stützpunkte, Linie = Taste drücken und Maus bewegen
F9                Bildschirminhalt in BILD_???.BMP schreiben, (zum Drucken)
F10               wie F9, jedoch Farbe[2] gestrichelt darstellen
R                 zeigt den     Realteil maximiert in Farbe[3] am Bildschirm
I                 zeigt den Imaginärteil maximiert in Farbe[3] am Bildschirm
B                 zeigt den Real-und Imaginärteil maximiert in Farbe[3]

Nachdem nun die Stützstellen eingeben wurden, und mit 'Enter' bestätigt wurden,
werden die fehlenden Stützstellen mit dem Interpolations-Filter interpoliert.
Dann wird das Ergebnis der Interpolation gezeigt, und man kann mittels F9 / F10
das Ergebnis der Interpolation als Windows 3.0 BMP-Datei abspeichern.
(Die BILD_???.BMP Dateien werden von 001 bis 999 durchnummeriert.)

Nun stehen folgende Tasten zur Verfügung:
-----------------------------------------
Esc                 Eingabe  abbrechen
1                   RC-Glättungsfilter Stärke 1
2                   RC-Glättungsfilter Stärke 2
3                   RC-Glättungsfilter Stärke 3
4                   RC-Glättungsfilter Stärke 4
5                   RC-Glättungsfilter Stärke 5
6                   RC-Glättungsfilter Stärke 6 
7                   Symetrischer-Glättungsfilter Stärke 1
8                   Symetrischer-Glättungsfilter Stärke 2
9                   Symetrischer-Glättungsfilter Stärke 3
0                   Symetrischer-Glättungsfilter Stärke 4
andere Tasten       Gleichanteil = 0, fortsetzen...
linke  Maustaste    Gleichanteil = 0, fortsetzen...
rechte Maustaste    Eingabe des Nullpegels und dann fortsetzen...

Eingabe des Nullpegels (+ Drehung):
Der Nullpegel wird durch eine Linie zwischen zwei Punkten dargestellt,
haben beide Punkte eine unterschiedliche Höhe, erfolgt zusätzlich eine Drehung.
Die Eingabe des  ersten Punktes erfolgt durch drücken der rechten Maustaste,
die Eingabe des zweiten Punktes erfolgt durch drücken einer beliebigen Taste.


Die Filter sind 1.Ordnung,aber durch mehrmaliges filtern entstehen auch Filter
beliebiger Ordnung. Je größer die Stärke des Glättungsfilters, desto kleiner
ist die Grenzfrequenz des äquivalenten Tiefpasses.
Mit jedem Filtern erhöht sich auch die Spline-Ordnung des Signals...

RC-Filter:
----------
Es wird eine Mittelung über eine durch die Stärke bestimmte Breite ausgeführt,
außerdem liegt eine Rückkoppelung vor, die dem Bildungsgesetz der Zahl e
nicht unähnlich ist, wenn Sprünge im Signal vorliegen...
Es dürfte infolge dessen nicht wundern, daß Rechteckimpulsen die exp()-Funktion
aufgeprägt wird, genauso wie bei einem RC-Tiefpass 1.Ordnung.
Infolge dessen gehe ich davon aus, daß dieses Filter sich auch so ähnlich wie
ein RC-Tiefpass 1.Ordnung verhält...

Symetrischer Filter:
--------------------
Es wird eine Vorwärts-Mittelung des Signals, mit einer durch die Stärke 
bestimmten Breite ausgeführt, ohne Rückkoppelung! 
Die Vorwärts-Mittelung hat den Nachteil einer Verschiebung in X-Richtung,
um zu verhindern, daß unser Signal bei mehreren Filterungen vom Bildschirm
wandert, wird abwechselnd nach links und nach rechts gemittelt.
Aufgrund der Ähnlichkeit von Integration und Mittelung über eine begrenzte
Breite, kann davon ausgegangen werden, daß dieser Filter ein entfernter
Verwandter des Integrators ist(der Frequenzverlauf entspricht der Si-Funktion).     
Rechteck und andere Signale, werden im Gegensatz zum RC-Filter symetrisch
verrundet, daher der Name 'Symetrischer Glättungsfilter'.


Nachdem wir nun gefiltert haben (oder auch nicht),
den Nullpegel festgelegt haben  (b.z.w. Gleichanteil = 0),
möchte das Programm gerne wissen wo, und wie es denn nun das Signal 
abzulegen hat, dies ist überigens die letzte Chance, um mit Esc abzubrechen!

Das Signal kann als reelle Daten im Speicher abgelegt werden, 
oder als Realteil / Imaginärteil komplexer Daten.

Wollen wir Polare Daten eingeben, 
speichern wir den Betrag als Realteil, und die Phase als Imaginärteil,
danach müssen wir noch von Polar nach Real & Imag. umrechnen...

#24  Eingabe mit Filtertyp Spezial

Eingabe des Signals mit Hilfe der Maus.
(Mit der Maus kann man Linien ziehen und Punkte setzen!)

Fehlende Punkte werden mit einem Spezial Interpolations-Filter errechnet,
dieser Filter beruht darauf, daß die mittlere Lückenbreite bestimmt wird,
die fehlenden Punkte linear verbunden werden, und dann wird zweimal gemittelt.
Die Mittelungsbreite ist proportional der mittleren Lückenbreite, dieser
Filter hat ein ähnliches Verhalten wie eine Spline-Interpolation, wenn genug
Stützstellen existieren, und die Lückenbreite nicht übermäßig schwankt!
Die Spline-Ordnung der interpolierten Stellen beträgt 1+2 (Linie+Mittelung).

Dieses Spezial-Filter ist absolut stabil, 
im Gegensatz zur Interpolationsformel von Lagrange,
die ursprünglich anstelle des Spezial-Filters stand, leider zeigte sich, daß
die Neigung zu wilden Überschwingen, mit steigender Stützstellenzahl immer
größer wurde. Wahrscheinlich versagt diese Interpolation gerade deshalb so
jämmerlich, weil von Hand eingegbene Werte nun mal nicht unbedingt einem
Polynom entsprechen, das würde erklären warum die Lagrangesche Interpolation
gerade bei steigender Stützstellenzahl immer unzuverlässiger wird, denn
bei steigender Stützstellenzahl, kristallisiert sich immer mehr heraus,
daß die eingegebene Funktion, eigentlich kein Polynom der durch die
Anzahl der Stützstellen gegebenen Ordnung ist.
Das häufig auftretende wilde Überschwingen, stellt zwar auch eine korrekte
Interpolation an den Stützstellen da, aber es wird ja letztendlich ein 
Polynom gesucht, das möglichst auch zwischen den Stützstellen brauchbar ist!

Nach dem Start der Eingabe stehen folgende Tasten zur Verfügung:
----------------------------------------------------------------
Esc               Eingabe abbrechen
Del               Bildschirm löschen, Gitter/DIV zeichnen, und wieder Eingabe
Enter             eingebene Stützstellen & Linien akzeptieren, fortsetzen
rechte Maustaste  eingebene Stützstellen & Linien akzeptieren, fortsetzen 
linke  Maustaste  setzt Stützpunkte, Linie = Taste drücken und Maus bewegen
F9                Bildschirminhalt in BILD_???.BMP schreiben, (zum Drucken)
F10               wie F9, jedoch Farbe[2] gestrichelt darstellen
R                 zeigt den     Realteil maximiert in Farbe[3] am Bildschirm
I                 zeigt den Imaginärteil maximiert in Farbe[3] am Bildschirm
B                 zeigt den Real-und Imaginärteil maximiert in Farbe[3]

Nachdem nun die Stützstellen eingeben wurden, und mit 'Enter' bestätigt wurden,
werden die fehlenden Stützstellen mit dem Interpolations-Filter interpoliert.
Dann wird das Ergebnis der Interpolation gezeigt, und man kann mittels F9 / F10
das Ergebnis der Interpolation als Windows 3.0 BMP-Datei abspeichern.
(Die BILD_???.BMP Dateien werden von 001 bis 999 durchnummeriert.)

Nun stehen folgende Tasten zur Verfügung:
-----------------------------------------
Esc                 Eingabe  abbrechen
1                   RC-Glättungsfilter Stärke 1
2                   RC-Glättungsfilter Stärke 2
3                   RC-Glättungsfilter Stärke 3
4                   RC-Glättungsfilter Stärke 4
5                   RC-Glättungsfilter Stärke 5
6                   RC-Glättungsfilter Stärke 6 
7                   Symetrischer-Glättungsfilter Stärke 1
8                   Symetrischer-Glättungsfilter Stärke 2
9                   Symetrischer-Glättungsfilter Stärke 3
0                   Symetrischer-Glättungsfilter Stärke 4
andere Tasten       Gleichanteil = 0, fortsetzen...
linke  Maustaste    Gleichanteil = 0, fortsetzen...
rechte Maustaste    Eingabe des Nullpegels und dann fortsetzen...

Eingabe des Nullpegels (+ Drehung):
Der Nullpegel wird durch eine Linie zwischen zwei Punkten dargestellt,
haben beide Punkte eine unterschiedliche Höhe, erfolgt zusätzlich eine Drehung.
die Eingabe des  ersten Punktes erfolgt durch drücken der rechten Maustaste,
die Eingabe des zweiten Punktes erfolgt durch drücken einer beliebigen Taste.


Die Filter sind 1.Ordnung,aber durch mehrmaliges filtern entstehen auch Filter
beliebiger Ordnung. Je größer die Stärke des Glättungsfilters, desto kleiner
ist die Grenzfrequenz des äquivalenten Tiefpasses.
Mit jedem Filtern erhöht sich auch die Spline-Ordnung des Signals...

RC-Filter:
----------
Es wird eine Mittelung über eine durch die Stärke bestimmte Breite ausgeführt,
außerdem liegt eine Rückkoppelung vor, die dem Bildungsgesetz der Zahl e
nicht unähnlich ist, wenn Sprünge im Signal vorliegen...
Es dürfte infolge dessen nicht wundern, daß Rechteckimpulsen die exp()-Funktion
aufgeprägt wird, genauso wie bei einem RC-Tiefpass 1.Ordnung.
Infolge dessen gehe ich davon aus, daß dieses Filter sich auch so ähnlich wie
ein RC-Tiefpass 1.Ordnung verhält...

Symetrischer Filter:
--------------------
Es wird eine Vorwärts-Mittelung des Signals, mit einer durch die Stärke 
bestimmten Breite ausgeführt, ohne Rückkoppelung! 
Die Vorwärts-Mittelung hat den Nachteil einer Verschiebung in X-Richtung,
um zu verhindern, daß unser Signal bei mehreren Filterungen vom Bildschirm
wandert, wird abwechselnd nach links und nach rechts gemittelt.
Aufgrund der Ähnlichkeit von Integration und Mittelung über eine begrenzte
Breite, kann davon ausgegangen werden, daß dieser Filter ein entfernter
Verwandter des Integrators ist(der Frequenzverlauf entspricht der Si-Funktion).     
Rechteck und andere Signale, werden im Gegensatz zum RC-Filter symetrisch
verrundet, daher der Name 'Symetrischer Glättungsfilter'.


Nachdem wir nun gefiltert haben (oder auch nicht),
den Nullpegel festgelegt haben  (b.z.w. Gleichanteil = 0),
möchte das Programm gerne wissen wo, und wie es denn nun das Signal 
abzulegen hat, dies ist überigens die letzte Chance, um mit Esc abzubrechen!

Das Signal kann als reelle Daten im Speicher abgelegt werden, 
oder als Realteil / Imaginärteil komplexer Daten.

Wollen wir Polare Daten eingeben,
speichern wir den Betrag als Realteil, und die Phase als Imaginärteil,
danach müssen wir noch von Polar nach Real & Imag. umrechnen...

#31  Status-Information anzeigen
Zeigt alle Status-Informationen zu den Daten im Speicher!
#32  Zeitb. <==vertauschen==> Freq.

Vertauscht FFTflag, die Daten werden nicht verändert, aber der Status
Daten im Zeitbereich / Frequenzbereich wird vertauscht!
Das ist dann sinnvoll, wenn Sie Daten importieren oder von Hand eingeben,
(FFT4WAVE geht nämlich dann davon aus,daß die Daten im Zeitbereich vorliegen)
Sie aber möchten, daß die Daten im Frequenzbereich vorliegen!

#33  ändere Abtastrate / Samplerate

Ändert die Samplerate (Abtastwerte pro Sekunde).
Nyquistkriterium (Shannons Abtasttheorem):  Grenzfrequenz = Samplerate / 2
Funktionen wie FFT reeller Daten, Ausschneiden in der Visualisierung,
und Oversampling linear/Filter korrigieren die Abtastrate! 

#36  ändere die Gesamtdauer

Ändert die Gesamtdauer der Daten!
Beeinflußt die Samplerate = Datenlänge(Anzahl_Abtastwerte) / Gesamtdauer
Funktionen wie FFT reeller Daten, Ausschneiden in der Visualisierung,
und Oversampling linear/Filter korrigieren die Abtastrate! 

#34  ändere Gitter_X / DIV Dauer

Ändert die Dauer eines Gitters (DIV)!
Das DIV ist ein Gitter in der Dateneingabe mit Filtertyp.{Eingabe mittels Maus}
Beeinflußt die Samplerate = Datenlänge(Anzahl_Abtastwerte) / (16*DIV_Dauer).
Funktionen wie FFT reeller Daten, Ausschneiden in der Visualisierung,
und Oversampling linear/Filter korrigieren die Abtastrate! 

#35  ändere Gitter_Y / DIV Amplitude

Ändert die Höhe eines Gitters (DIV) der Dateneingabe mit Filtertyp.  {Maus}
Ändern sie bitte die Höhe, bevor sie die Daten eingeben, denn diese Änderung
beeinflußt nur nachfolgende Dateneingaben mit Filtertyp...

#52  Y-Scalierung und Information

Diese Funktion zeigt die Häufigkeit von Amplitudenwerten an, hiermit kann
man sehr schnell erkennen, ob und wie stark die Daten übersteuert wurden,
und welcher Art die Daten ungefähr sind.
Außerdem wird der Größte, von Null entfernte Datenwert 'Y- Maximum' bestimmt.
Dieser größte Datenwert, wird auch zur Skalierung der Darstellung verwendet!
Die Differenz zwischen den größten ±Werten (Peak to Peak),
wird ebenfalls ermittelt, und als Zahl angezeigt.
Natürlich wird auch der Gleichanteil bestimmt und als DC/Offset angezeigt.
Fast alle Soundkarten lassen den Gleichanteil des Eingangssigals nicht durch!
(Dieser wird mit Hilfe eines Hochpasses (Kondensator) blockiert.)
Trotzdem haben leider fast alle Soundkarten einen Offsetfehler, und da der
Gleichanteil blockiert wird, ist der DC/Offset der Offsetfehler der Soundkarte.

DC_Offset = Effektivwert des  Gleichanteils
Y_eff    = Effektivwert des Wechselanteils
                          _________________________
 gesamte Effektivwert =  √  DC_Offset²  +  Y_eff²

Mit den Tasten F9 und F10 können wir jetzt den Grafikbildschirm ausdrucken.

Ein Tastendruck bringt weitere Möglichkeiten zum Vorschein:
-----------------------------------------------------------
Die Taste 'Esc' oder das Auswahlfeld 'STOP!' bricht die Funktion ab!
Die weiteren möglichen Auswahlfelder 'New Amplitude ?' ; 'Real & Imag.' ;
'only Real' und 'only Imag.' erlauben es, die Werte aller Daten neu zu
skalieren, der Bezugspunkt ist dabei 'Y - Maximum'.

'New Amplitude ?'    skaliert reelle Daten. 
'Real & Imag.'       skaliert komplexe Daten auf einen Bezugspunkt. 
'only Real.'         skaliert nur den     Realteil komplexer Daten.
'only Imag.'         skaliert nur den Imaginärteil komplexer Daten.

Es spielt eine wichtige Rolle, ob man mit der linken Maustaste, oder mit der
rechten Maustaste auf das Auswahlfeld klickt, wenn man nämlich mit der
rechten Maustaste auf das Auswahlfeld klickt, dann wird nicht nur skaliert,
sondern es wird auch der Gleichanteil weggerechnet!

#53  X-Scalierung (Oversampling)
           Die X-Skalierung besteht aus 3 Funktionen:
          ════════════════════════════════════════════

'Impossibility Drive'    'Oversampling Linear'    'Oversampling Filter'

Impossibility Drive:
---------------------
Es wird die Eingabe einer neuen Datenlänge, oder eines Multiplikationsfaktors
erwartet, ist der Wert unlogisch wird die Funktion abgebrochen.
Es werden alle Datenformate unterstützt!

Wenn eine kleine Zahl eingegeben wurde, dann handelt es sich um einen
Multiplikationsfaktor 'Multiply' und die Daten werden dupliziert (wiederholt).
Die Gesamtdauer erhöht sich dabei logischerweise um den Multiplikationsfaktor.

Wenn eine neue Datenlänge eingegeben wurde, werden die Daten mit dem letzten
gültigen Datenwert, bis zur Datenlänge aufgefüllt (nicht überschrieben!).
Es wird nicht mit Null aufgefüllt, um Sprünge zu vermeiden, dafür entsteht
jedoch möglicherweise ein unerwünschter Gleichanteil...



Oversampling Linear:
---------------------
Es werden alle Datenformate unterstützt!
Es wird die Eingabe einer neuen Datenlänge erwartet, danach werden die
Daten auf die neue Datenlänge 'gedehnt' , b.z.w. interpoliert.
Die physikalische in Visualisierung dargestellte Skalierung,
verändert sich dabei nicht. Nur die Anzahl der Daten, durch die
diese physikalische Skalierung repräsentiert wird, ändert sich...
Man könnte der Datenlänge also die Bedeutung 'Präzision' zuschreiben.
Wenn man die neue Datenlänge größer als die alte Datenlänge macht,
dann entspricht diese Funktion dem Oversampling!
Das heißt, die Gefahr des Auftretens von Alising/Bandüberlappung sinkt.
Die Interpolation erfolgt linear, ähnlich der B-Spline Interpolation 2.Ordnung.



Oversampling Filter:
---------------------
Es werden nur reelle Daten unterstützt!
Es wird die Eingabe einer neuen Datenlänge erwartet, danach werden die
Daten auf die neue Datenlänge 'gedehnt' , b.z.w. interpoliert.
Die physikalische in Visualisierung dargestellte Skalierung,
verändert sich dabei nicht. Nur die Anzahl der Daten, durch die
diese physikalische Skalierung repräsentiert wird, ändert sich...
Man könnte der Datenlänge also die Bedeutung 'Präzision' zuschreiben.
Wenn man die neue Datenlänge größer als die alte Datenlänge macht,
dann entspricht diese Funktion dem Oversampling!
Das heißt, die Gefahr des Auftretens von Alising / Bandüberlappung sinkt.
Die Interpolation erfolgt mit Hilfe eines Filters, mögliche Filter haben
die Endung   *_.FFT      .Unsere Daten werden mit dem Filter gefaltet, und
zwar mit der Wilden Diskreten Faltung (WDF). Diese Faltung erlaubt es, reelle
diskrete Daten unterschiedlicher Datenlänge, und unterschiedlicher Skalierung
miteinander zu falten, und das auch noch auf eine neue Datenlänge!
Außerdem tritt kein Amplitudenfehler auf, und die Geschwindigkeit mit der
die Wilde Diskrete Faltung ausgeführt wird, ist sehr hoch!

Das ganze beruht auf der verallgemeinerten Abtastreihe (VAR), und
der Filter repäsentiert einen 'Kern für verallgemeinerte Abtastreihen' (KVAR)

                        Filter(t)  =  KVAR(πt)

Da es sich bei dem Filter (KVAR) um eine gerade Funktion handelt, wird nur
die zweite (positive) Hälfte des Filters gelesen, und um den Faktor 2 linear
interpoliert. Jetzt wird der Filter so angesprochen: y = Filter( abs(t) )
Dieses Filter hat eine virtuelle Datenlänge von 32768.

#56  Nullpunktvertauschung_X

Vertauscht die erste Hälfte der Daten, mit der zweiten Hälfte der Daten.
Zweimalige Ausführung erzeugt also wieder den Originalzustand (wie bei der FFT).

Die Frage ist, was bedeutet das für uns ?
------------------------------------------
Der FFT Algorithmus zwingt, wie wir wissen, unseren Daten Periodiztät mit der
Datenlänge auf, und zwar sowohl im Frequenzbereich, als auch im Zeitbereich.
Daraus folgt, daß wir den linken Rand ( = 0 ) und auch den rechten Rand
( = Samplerate, Gesamtdauer) der Daten, als Nullpunkt in X-Richtung betrachten
können, aufgrund der Periodizität (unendliche Wiederholung der Daten).

Die Wirkung der Vertauschung ist so, als währe der Nullpunkt in die Mitte
der Daten verschoben worden, und wir erhalten eine Darstellung der FFT-Daten,
wie wir es gewohnt sind. Umgekehrt können wir unsere gewohnte Darstellung der
Daten, damit natürlich auch in die Darstellung der FFT überführen...

Es sind alle Datenformate zulässig, allerdings ergibt es keinen Sinn, diese
Funktion auf die durch 'FFT reeller Daten' erzeugten komplexen Daten
anzuwenden, denn diesen fehlt ja eine symetrische (negative) Hälfte, man würde
also das erste 1/4 mit dem zweiten 1/4 vertauschen, was jedoch sinnlos ist!

Wenn die Datenlänge ungerade ist, dann hat nicht nur der FFT-Algorithmus
Probleme, auch diese Funktion spinnt dann ein wenig.

(Ein einzelnener Datenwert bleibt wo er ist, wird also nicht vertauscht!)

#30  umwandeln:  Polar => Real,Imag.

Umwandeln von polaren komplexen Daten, in real&imaginäre komplexe Daten.
------------------------------------------------------------------------
Dazu legt man den Betrag der polaren komplexen Daten als Realteil ab,
und die Phase der polaren komplexen Daten als Imaginärteil ab.
Die Phase muß ein Winkel von 0...360°, b.z.w  von -180°...180° sein.

Der Aufruf dieser Funktion, wandelt dann die im Realteil und Imaginärteil
abgelegten polaren komplexen Daten, in den tatsächlichen Realteil und 
Imaginärteil komplexer Daten um...

#55  Absoluter Fehler: MEMORY - Datei.FFT

Bildet die Differenz zwischen den im Speicher abgelegten Daten und den
in der ausgewählten *.FFT Datei abgelegten Daten.

Dazu ist es erforderlich, daß die Datenlänge und der Datentyp (Reell/Komplex)
übereinstimmt, andernfalls läßt sich die Differenz nicht berechnen.
Wenn die Samplerates, oder der Zustand (Zeitbereich/Frequenzbereich)
unterschiedlich sind, wird darauf hingewiesen, die Differenz kann jedoch
gebildet werden (das Ganze ergibt dann nur möglicherweise keinen Sinn).

Wenn man die Daten in der *.FFT Datei, als die korrekten Werte im Sinne der
Fehlerrechnung betrachtet, dann ist die Differenz der Absolute Fehler!

#60  complexe Faltung: MEMORY * Datei.FFT

Faltet die im Speicher abgelegten komplexen Daten,
mit den in der ausgewählten *.FFT Datei abgelegten komplexen Daten.

Dazu ist es erforderlich, daß die Datenlänge übereinstimmt,
andernfalls läßt sich die Faltung nicht realisieren.
Wenn die Samplerates oder der Zustand (Zeitbereich/Frequenzbereich)
unterschiedlich sind, wird darauf hingewiesen, die Faltung ist jedoch möglich.
(Das Ganze ergibt dann nur möglicherweise keinen Sinn...)

Da diese Faltung auf der FFT beruht, sind die Daten als periodisch zu
betrachten, infolge der dadurch nötigen Amplitudenkorrekturfaktoren,
ergibt sich ein großes Problem: Denn Diracstöße (mit Amplitude statt Gewicht),
periodische Signale, und nichtperiodische Impulse, benötigen leider
alle unterschiedliche Amplitudenkorrekturfaktoren, daraus ergeben sich
neun mögliche unterschiedliche Amplitudenkorrekturfaktoren !!!

Außerdem gibt es keine einfach Möglichkeit für den Algorithmus, zu erkennen
um welchen Fall es sich überhaupt handelt. Es ist also so gut wie unmöglich
zu realisieren, daß die Amplitude stimmt, leider.

Die Form der gefalteten Daten stimmt jedoch, solange kein Randeffekt auftritt!

Wenn beide Samplerates identisch sind, dann stimmt die X-Skalierung.


Diese Faltung dient weniger der Mathematik, sondern ist vielmehr als
Universal-Filter gedacht, um beliebige lineare Übertragungssysteme zu
realisieren. Das funktioniert so:

g(t) = s(t) * h(t)

s(t) ist unser komplexes Eingangssignal im Zeitbereich.
g(t) ist unser komplexes Ausgangssignal im Zeitbereich.
h(t) ist die inverse Fouriertransformierte des Filterfrequenzgangs,
            b.z.w. die Stoßantwort des Filters auf einen Diracstoß.

Selbstverständlich kann man mit Hilfe von FFT4WAVE solche Filter erzeugen,
Ähnlichkeiten mit der Funktion 'Oversampling Filter' sind rein unzufällig,
dort wird jedoch ein exakterer Faltungsalgorithmus verwendet,
und es werden reelle Daten gefaltet...

#54  Hanning Fenster

Alle Daten, egal ob Reell oder Komplex, Zeitbereich oder Frequenzbereich,
werden mit einem Hanning Fenster multipliziert (0.5-0.5*cos(2πt/T)).

Selbiges bewirkt, daß die Daten am Datenanfang und am Datenende gegen 0 gehen.
Der Sprung zwischen Datenanfang und Datenende, der durch die von der FFT
aufgezwungende Periodizität entsteht, wenn die Datenlänge kein ganzzahliges
Vielfaches der Periode der Daten ist, verschwindet dadurch.

Und da das Hanning Fenster als Periode die ganze Datenlänge hat,
wird im Frequenzbereich nur ein einzelner Datenwert, in der Nähe von Null durch
das Hanning Fenster verfälscht. Allerdings fällt das ganze Spektrum
etwas niedriger aus, und es gibt leider keinen konstanten Korrekturfaktor!
Also stimmt die Form des Spektrums bis auf einen einzelnen Datenwert.

Der Leckeffekt wird hiermit reduziert, allerdings werden die Spektrallinien
auch etwas breiter, aber damit kann man leben...

#51  Visualisierung

Diese Funktion dient zur grafischen Anzeige (und zum Ausdruck) von Abtastwerten.
Außerdem kann die Datenmenge auf das Zoom-Fenster reduziert werden, mit anderen
Worten, es ist möglich das Zoom-Fenster aus den gesamten Daten auszuschneiden.
Danach besteht die Gesamtheit der Daten nur noch aus dem Inhalt des
Zoom-Fensters, der Rest der Daten ist unwiederbringlich weg!

In der linken oberen Ecke, sehen wir die Zahlenwerte der Daten, über denen der
Fadenkreuz-Cursor gerade steht, damit kann man die Daten sehr gut vermessen.
Insbesondere deshalb, weil die Möglichkeit besteht, den Nullpunkt beliebig mit
den Tasten 'S'  'X' und 'Y' auf die Cursorposition zu setzen.
Wenn ein neuer Nullpunkt gesetzt wird, dann steht vor den Zahlen ein Delta,
um auszudrücken, daß eine Differenz (Entfernung, Abstand) bestimmt wird!


Es stehen folgende Tasten zur Verfügung:
-------------------------------------------------------------------------------
F1               Zeigt Tastenbelegung an  (Quick Help)
F9               Ausdruck in BILD_???.BMP Datei, (Windows 3.0 s/w Grafikformat)
F10              Ausdruck in BILD_???.BMP Datei, Farbe[2] wird gestrichelt
<--              Ausschneiden des aktuellen (Zoom)-Fensters und dann abbrechen
Esc              Anzeige der Daten abbrechen.
S                Setzen eines neuen Nullpunktes für X und Y
X                Setzen eines neuen Nullpunktes für X
Y                Setzen eines neuen Nullpunktes für Y
N                Wiederherstellen des Original-Nullpunkts
Z                Wiederherstellen des Original-Nullpunkts
+                Amplitude 'Zoom in'    (Fenster in Y-Richtung vergrößern )
-                Amplitude 'Zoom out'   (Fenster in Y-Richtung verkleinern)
linke  Maustaste 'Zoom in' setzt linke obere Ecke des neuen Fensters, noch ein
                 Druck der linken Maustaste setzt dann die untere rechte Ecke.
                 Jede andere Taste bricht den 'Zoom in' ab.
rechte Maustaste 'Zoom out', Fenster um Faktor 4 vergrößern.


Die folgenden Tasten stehen nur bei komplexen Daten zur Verfügung:
-------------------------------------------------------------------
A                Amplitude (Betrag)
L                20 * log10(Betrag)
P                Polare Darstellung, Betrag und Phase.
R                Nur     Realteil zeigen
I                Nur Imaginärteil zeigen
B                Realteil und Imaginärteil auf zweigeteiltem Bildschirm zeigen

#50  FFT / inverse FFT
Fast Fourier Transformation:
----------------------------
Diese Funktion führt die FFT, oder die inverse FFT der Daten durch, 
je nachdem ob der Status der Daten Zeit oder Frequenz ist.

Die Daten im Zeitbereich stellen ein sich kontinuierlich wiederholendes Signal
dar.  Das ist gar nicht so leicht nachzuweisen, denn das Auflösungsgesetz der
FFT lautet etwa so:    PeriodenbreiteFrequenz = Datenlänge / PeriodenbreiteZeit
Ein Signal mit der Periodenbreite Datenlänge hätte also einen Spektrallinien-
abstand von 1, was gleichbedeutend damit ist, daß wir keinen Unterschied
zwischen wiederholend & nicht_wiederholend wahrnehmen können, weil dieser in
der begrenzten Auflösung der FFT untergeht.

Einen sehr wichtigen Unterschied gibt es jedoch, wenn die FFT eines
nichtkontinuierlichen Impulses erfolgt: Die kontinuierliche Darstellung eines
nichtkontinuierlichen Impulses, entspricht der Faltung desselben Impulses, mit
einer Diracstoßfolge des Gewichts (1) und des Abstands 'Gesamtdauer',
die FFT einer Diracstoßfolge enthält aber den Amplitudenfaktor 1/Gesamtdauer,
und genau dieser Faktor verfälscht die Höhe der Amplitude.
Das Problem tritt nicht bei kontinuierlichen Signalen auf!
Wenn wir also die tatsächliche Amplitude nichtkontinuierlicher Impulse
bestimmen wollen, multiplizieren wir die Amplitude mit der Gesamtdauer!!!

Folgendes Bild illustriert, wie man die Wiederholung beweisen kann:

nicht wiederholend                           wiederholend
 ╔═════════════╗                           ╔═════════════╗
 ║─┐         ┌─║           ┌───┐         ┌─║─┐         ┌─║─┐         ┌───┐
 ║ │         │ ║     ....  │   │         │ ║ │         │ ║ │         │   │ ....
 ║ └─────────┘ ║         ──┘   └─────────┘ ║ └─────────┘ ║ └─────────┘   └─
 ╚═════════════╝                           ╚═════════════╝
 2 kurze Impulse                            lange Impulse

Es stehen grundsätzlich zwei FFT/inverseFFT Algorithmen zur Verfügung: Die 
FFT/inverseFFT von komplexen Daten, und die FFT/inverseFFT von reellen Daten.
Die FFT von komplexen Daten hat den Vorteil,daß auch die inverse FFT garantiert
immer klappt; die FFT von reellen Daten nutzt dafür den Speicher effizienter.
Obwohl beide FFTs im Frequenzbereich komplexe Daten liefern, gibt es einen
wichtigen Unterschied: Die FFT reeller Daten liefert nur 0...Samplerate/2,
während die FFT komplexer Daten 0...Samplerate liefert. Diese zusätzlichen
Daten sind jedoch in der Regel lediglich eine Spiegelung um Samplerate/2;
da die Daten im Frequenzbereich mit Samplerate periodisch sind, entspricht
Samplerate gleich 0, und der Sprung von + nach - findet bei Samplerate/2 statt.
Man kann eine FFT reeller Daten auch dadurch realisieren, daß man die reellen
Daten in komplexe Daten umwandelt, indem man den Imaginärteil mit 0 füllt
(und die reellen Daten als Realteil komplexer Daten ablegt).

Leider verarbeitet die FFT nicht Daten beliebiger Länge, 
sondern stürzt ab, wenn die Daten in einer unsinnvollen Datenlänge vorliegen.
Vielfache von 4 funktionieren besonders schnell, aber auch Faktoren 
wie 2, 3, 5, 7, 11, 13, ... dürfen in der Datenlänge enthalten sein.

Tip:  Es ist sehr oft sinnvoll, mittels Oversampling die Datenlänge zu ändern!


Lars Otte, 
           Autor von FFT4WAVE


------------------------------------------------------------------------------
THIS PROGRAM CALCULATES THE FAST FOURIER TRANSFORM OF VERY LONG SERIES,
AS LONG AS YOUR FAR HEAP ALLOWS. FOR EXAMPLE, USING DOUBLE PRECISION IT
IS POSSIBLE TO PROCESS 70.000 REAL DATA POINTS. IT IMPLEMENTS R. C.
SINGLETON'S MIXED RADIX FAST FOURIER ALGORITHM. SOME FEATURES OF THIS
ALGORITHM ARE: 1) THE LENGTH OF THE SERIES DOES NOT HAVE TO BE BE
NECESSARILY A POWER OF TWO, THE LENGTH MAY INCLUDE FACTORS OF 2 AND 4,
AND ALSO ODD FACTORS AS 3,5,7, ETC,2-) TO AVOID TRUNCATION ERRORS, THE
SINES AND COSINES ARE GENERATED RECURSIVELY, 3-) THE DATA AND ITS
TRANSFORM ARE ACCESSED WITH HUGE POINTERS.


DATA SIZE RESTRICTION:

The series has to fit in conventional memory (ie. far heap). Using
double precision it means somewhere around 70.000 real data points
(547 K bytes), depending on your system configuration.

  
TRUNCATION ERRORS ARE A BIG PROBLEM:

First I used two FFT subroutines found in SYMTEL and modified them
using huge pointers to access the data. Everything worked fine until
I started transforming series 12K long and above. It took me a while
to figure out the problem was in the truncation errors when calculating
the sines and cosines using the library functions.

METHOD:

I translated to C, R. C. Singleton's mixed radix fast Fourier transform
algorithm (see reference in SING.C). His algorithm generates the 
sines and cosines recursively and corrects for truncation errors.

DATA LENGTH

Does not have to be a power of 2 necessarily. The length can contain
even factors as 2 and 4, and also odd factors as 3,5, 7, 11, etc.
The algorithm is most efficient if the length is a power of four.
Data lengths with odd factors of 3 and 5 can be used without a great
loss in performance.


    This functions are translations from the fortran program in
    R. C. Singleton, An algorithm for computing the mixed radix fast
    Fourier transform 
  
    IEEE Trans. Audio Electroacoust., vol. AU-17, pp. 93-10, June 1969.

**************************************************************
*  Javier Soley, Ph. D,   FJSOLEY @UCRVM2.BITNET             *
*  Escuela de Física y Centro de Investigaciones Geofísicas  *
*  Universidad de Costa Rica                                 *
**************************************************************